Title Banner

Previous Book Contents Book Index Next

Inside Macintosh: QuickTime Components /
Chapter 6 - Sequence Grabber Channel Components


Summary of Sequence Grabber Channel Components

C Summary

Constants

/* sequence grabber channel component type */
#define SeqGrabChannelType 'sgch'
/* device list structure flags */
#define sgDeviceListWithIcons (1)               /* include icons */
#define sgDeviceListDontCheckAvailability (2)   /* don't check available */

/* data function write operation types */
enum {
   seqGrabWriteAppend,              /* append to file */
   seqGrabWriteReserve,             /* reserve space in file */
   seqGrabWriteFill                 /* fill reserved space */
};
/* flags for SGSetChannelPlayFlags and SGGetChannelPlayFlags functions */
#define channelPlayNormal 0      /* use default playback methodology */
#define channelPlayFast 1        /* achieve fast playback rate */
#define channelPlayHighQuality 2 /* achieve high-quality image */
#define channelPlayAllData 4     /* play all captured data */
/* usage flags for SGSetChannelUsage and SGGetChannelUsage functions */
enum {
   seqGrabRecord           = 1,  /* used during record operations */
   seqGrabPreview          = 2,  /* used during preview operations */
   seqGrabPlayDuringRecord = 4   /* plays data during record operation */
};
typedef unsigned char SeqGrabUsageEnum;
/* SGGetChannelInfo function flags */
enum {
   seqGrabHasBounds           = 1,  /* visual representation of data */
   seqGrabHasVolume           = 2,  /* audio representation of data */ 
   seqGrabHasDiscreteSamples  = 4   /* data organized in discrete frames */
};
typedef unsigned char SeqGrabChannelInfoEnum;
/* basic sequence grabber channel component selectors */
kSGSetGWorldSelect               = 0x4;   /* SetGWorld */ 
kSGStartPreviewSelect            = 0x10;  /* SGStartPreview */ 
kSGStartRecordSelect             = 0x11;  /* SGStartRecord */ 
kSGIdleSelect                    = 0x12;  /* SGIdle */ 
kSGStopSelect                    = 0x13;  /* SGStop */ 
kSGPauseSelect                   = 0x14;  /* SGPause */ 
kSGPrepareSelect                 = 0x15;  /* SGPrepare */ 
kSGReleaseSelect                 = 0x16;  /* SGRelease */ 
kSGUpdateSelect                  = 0x27;  /* SGUpdate */

/*  selectors for common channel configuration functions */
kSGCSetChannelUsageSelect        = 0x80;  /* SGSetChannelUsage */ 
kSGCGetChannelUsageSelect        = 0x81;  /* SGGetChannelUsage */ 
kSGCSetChannelBoundsSelect       = 0x82;  /* SGSetChannelBounds */ 
kSGCGetChannelBoundsSelect       = 0x83;  /* SGGetChannelBounds */ 
kSGCSetChannelVolumeSelect       = 0x84;  /* SGSetChannelVolume */ 
kSGCGetChannelVolumeSelect       = 0x85;  /* SGGetChannelVolume */ 
kSGCGetChannelInfoSelect         = 0x86;  /* SGGetChannelInfo */ 
kSGCSetChannelPlayFlagsSelect    = 0x87;  /* SGSetChannelPlayFlags */   
kSGCGetChannelPlayFlagsSelect    = 0x88;  /* SGGetChannelPlayFlags */ 
kSGCSetChannelMaxFramesSelect    = 0x89;  /* SGSetChannelMaxFrames */ 
kSGCGetChannelMaxFramesSelect    = 0x8A;  /* SGGetChannelMaxFrames */ 
kSGCSetChannelRefConSelect       = 0x8B;  /* SGSetChannelRefCon */ 
kSGCSetChannelClipSelect         = 0x8C;  /* SGSetChannelClip */
kSGCGetChannelClipSelect         = 0x8D;  /* SGGetChannelClip */
kSGCGetChannelSampleDescriptionSelect = 0x8E;
                                       /* SGCGetChannelSampleDescription */
kSGCGetChannelDeviceListSelect   = 0x8F;  /* SGCGetChannelDeviceList */
kSGCSetChannelDeviceSelect       = 0x90;  /* SGCSetChannelDevice */
kSGCSetChannelMatrixSelect       = 0x91;  /* SGCSetChannelMatrix */
kSGCGetChannelMatrixSelect       = 0x92;  /* SGCGetChannelMatrix */
kSGCGetChannelTimeScaleSelect    = 0x93;  /* SGCGetChannelTimeScale */
      
/*  selectors for video channel configuration functions */
kSGCGetSrcVideoBoundsSelect      = 0x100; /* SGCGetSrcVideoBounds */ 
kSGCSetVideoRectSelect           = 0x101; /* SGCSetVideoRect */ 
kSGCGetVideoRectSelect           = 0x102; /* SGCGetVideoRect */ 
kSGCGetVideoCompressorTypeSelect = 0x103; /* SGCGetVideoCompressorType */ 
kSGCSetVideoCompressorTypeSelect    = 0x104; /* SGCSetVideoCompressorType */ 
kSGCSetVideoCompressorSelect        = 0x105; /* SGCSetVideoCompressor */ 
kSGCGetVideoCompressorSelect        = 0x106; /* SGCGetVideoCompressor */ 
kSGCGetVideoDigitizerComponentSelect= 0x107; 
                                          /* SGCGetVideoDigitizerComponent */ 
kSGCSetVideoDigitizerComponentSelect= 0x108; 
                                          /* SGCSetVideoDigitizerComponent */ 
kSGCVideoDigitizerChangedSelect     = 0x109; /* SGCVideoDigitizerChanged */ 
kSGCSetVideoBottlenecksSelect       = 0x10a; /* SGCSetVideoBottlenecks */
kSGCGetVideoBottlenecksSelect       = 0x10b; /* SGCGetVideoBottlenecks */ 
kSGCGrabFrameSelect                 = 0x10c; /* SGCGrabFrame */ 
kSGCGrabFrameCompleteSelect         = 0x10d; /* SGCGrabFrameComplete */ 
kSGCDisplayFrameSelect              = 0x10e; /* SGCDisplayFrame */ 
kSGCCompressFrameSelect             = 0x10f; /* SGCCompressFrame */ 
kSGCCompressFrameCompleteSelect     = 0x110; /* SGCCompressFrameComplete */ 
kSGCAddFrameSelect                  = 0x111; /* SGCAddFrame */ 
kSGCTransferFrameForCompressSelect  = 0x112; 
                                          /* SGCTransferFrameForCompress */ 
kSGCSetCompressBufferSelect         = 0x113; /* SGCSetCompressBuffer */ 
kSGCGetCompressBufferSelect         = 0x114; /* SGCGetCompressBuffer */ 
kSGCGetBufferInfoSelect             = 0x115; /* SGCGetBufferInfo */ 
kSGCSetUseScreenBufferSelect        = 0x116; /* SGCSetUseScreenBuffer */
kSGCGetUseScreenBufferSelect        = 0x117; /* SGCGetUseScreenBuffer */
kSGCGrabCompressCompleteSelect      = 0x118; /* SGCGrabCompressComplete */
kSGCDisplayCompressSelect           = 0x119; /* SGCDisplayCompress */
kSGCSetFrameRateSelect              = 0x11A; /* SGCSetFrameRate */
kSGCGetFrameRateSelect              = 0x11B; /* SGCGetFrameRate */
    
/* selectors for sound channel configuration functions */
kSGCSetSoundInputDriverSelect       = 0x100; /* SGCSetSoundInputDriver */ 
kSGCGetSoundInputDriverSelect       = 0x101; /* SGCGetSoundInputDriver */ 
kSGCSoundInputDriverChangedSelect   = 0x102; /* SGCSoundInputDriverChanged */ 
kSGCSetSoundRecordChunkSizeSelect   = 0x103; /* SGCSetSoundRecordChunkSize */ 
kSGCGetSoundRecordChunkSizeSelect   = 0x104; /* SGCGetSoundRecordChunkSize */ 
kSGCSetSoundInputRateSelect         = 0x105; /* SGCSetSoundInputRate */ 
kSGCGetSoundInputRateSelect         = 0x106; /* SGCGetSoundInputRate */ 
kSGCSetSoundInputParametersSelect   = 0x107; /* SGCSetSoundInputParameters */
kSGCGetSoundInputParametersSelect   = 0x108; /* SGCGetSoundInputParameters */

/* selectors for channel control functions */
kSGCInitChannelSelect               = 0x180; /* SGCInitChannel */ 
kSGCWriteSamplesSelect              = 0x181; /* SGCWriteSamples */ 
kSGCGetDataRateSelect               = 0x182; /* SGCDataRate */
kSGCAlignChannelRectSelect          = 0x183; /* SGAlignChannelRect */
}; 
/* values for pause parameter of SGPause function */
enum {
   seqGrabUnpause = 0,  /* restart the current operation */
   seqGrabPause   = 1,  /* pause the current operation */
};

Data Types

struct SeqGrabFrameInfo {
   long        frameOffset;   /* offset to the sample */
   long        frameTime;     /* time that frame was captured */
   long        frameSize;     /* number of bytes in sample */
   SGChannel   frameChannel;  /* current connection to channel */
   long        frameRefCon;   /* reference constant for channel */
};
typedef struct SGDeviceListRecord {
   short          count;            /* count of devices */
   short          selectedIndex;    /* current device */
   long           reserved;         /* set to 0 */
   SGDeviceName   entry[1];         /* device names */
} SGDeviceListRecord, *SGDeviceListPtr, **SGDeviceList;
typedef struct SGDeviceName {
   Str63       name;             /* device name */
   Handle      icon;             /* device icon */
   long        flags;            /* flags */
   long        refCon;           /* set to 0 */
   long        reserved;         /* set to 0 */
} SGDeviceName;

Functions

Configuring Sequence Grabber Channel Components

pascal ComponentResult SGInitChannel
(SGChannel c, SeqGrabComponent owner);
pascal ComponentResult SGSetGWorld
(SeqGrabComponent s, CGrafPtr gp, GDHandle gd);

Controlling Sequence Grabber Channel Components

pascal ComponentResult SGStartPreview
(SeqGrabComponent s);
pascal ComponentResult SGStartRecord
(SeqGrabComponent s);
pascal ComponentResult SGIdle
(SeqGrabComponent s);
pascal ComponentResult SGUpdate
(SeqGrabComponent s, RgnHandle updateRgn);
pascal ComponentResult SGStop
(SeqGrabComponent s);
pascal ComponentResult SGWriteSamples
(SGChannel c, Movie m, AliasHandle theFile);
pascal ComponentResult SGPause 
(SeqGrabComponent s, Byte pause);
pascal ComponentResult SGPrepare 
(SeqGrabComponent s, Boolean prepareForPreview, 
Boolean prepareForRecord);
pascal ComponentResult SGRelease
(SeqGrabComponent s);

Configuration Functions for All Channel Components

pascal ComponentResult SGSetChannelUsage 
(SGChannel c, long usage);
pascal ComponentResult SGGetChannelUsage 
(SGChannel c, long *usage);
pascal ComponentResult SGGetChannelInfo
(SGChannel c, long *channelInfo);
pascal ComponentResult SGSetChannelPlayFlags
(SGChannel c, long playFlags);
pascal ComponentResult SGGetChannelPlayFlags
(SGChannel c, long *playFlags);
pascal ComponentResult SGSetChannelMaxFrames
(SGChannel c, long frameCount);
pascal ComponentResult SGGetChannelMaxFrames
(SGChannel c, long *frameCount);
pascal ComponentResult SGSetChannelRefCon
(SGChannel c, long refCon);
pascal ComponentResult SGGetDataRate
(SGChannel c, long *bytesPerSecond);
pascal ComponentResult SGGetChannelSampleDescription 
(SGChannel c, Handle sampleDesc);
pascal ComponentResult SGGetChannelTimeScale 
(SGChannel c, TimeScale *scale);
pascal ComponentResult SGSetChannelClip 
(SGChannel c, RgnHandle theClip);
pascal ComponentResult SGGetChannelClip 
(SGChannel c, RgnHandle *theClip);
pascal ComponentResult SGSetChannelMatrix 
(SGChannel c, const MatrixRecord *m);
pascal ComponentResult SGGetChannelMatrix 
(SGChannel c, MatrixRecord *m);

Working With Channel Devices

pascal ComponentResult SGGetChannelDeviceList 
(SGChannel c, long selectionFlags, 
SGDeviceList *list);
pascal ComponentResult SGSetChannelDevice 
(SGChannel c, StringPtr name);

Configuration Functions for Video Channel Components

pascal ComponentResult SGSetChannelBounds
(SGChannel c, Rect *bounds);
pascal ComponentResult SGGetChannelBounds 
(SGChannel c, const Rect *bounds);
pascal ComponentResult SGGetSrcVideoBounds
(SGChannel c, Rect *r);
pascal ComponentResult SGSetVideoRect
(SGChannel c, Rect *r);
pascal ComponentResult SGGetVideoRect 
(SGChannel c, Rect *r);
pascal ComponentResult SGSetVideoCompressorType 
(SGChannel c, OSType compressorType);
pascal ComponentResult SGGetVideoCompressorType 
(SGChannel c, OSType *compressorType);
pascal ComponentResult SGSetVideoCompressor 
(SGChannel c, short depth, 
CompressorComponent compressor, 
CodecQ spatialQuality, CodecQ temporalQuality, long keyFrameRate);
pascal ComponentResult SGGetVideoCompressor 
(SGChannel c, short *depth, 
CompressorComponent *compressor, 
CodecQ *spatialQuality, 
CodecQ *temporalQuality, long *keyFrameRate);
pascal ComponentResult SGSetVideoDigitizerComponent 
(SGChannel c, ComponentInstance vdig);
pascal ComponentInstance SGGetVideoDigitizerComponent 
(SGChannel c);
pascal ComponentResult SGVideoDigitizerChanged 
(SGChannel c);
pascal ComponentResult SGSetCompressBuffer 
(SGChannel c, short depth, 
const Rect *compressSize);
pascal ComponentResult SGGetCompressBuffer 
(SGChannel c, short *depth, Rect *compressSize);
pascal ComponentResult SGSetFrameRate 
(SGChannel c, Fixed frameRate);
pascal ComponentResult SGGetFrameRate 
(SGChannel c, Fixed *frameRate);
pascal ComponentResult SGSetUseScreenBuffer 
(SGChannel c, Boolean useScreenBuffer);
pascal ComponentResult SGGetUseScreenBuffer 
(SGChannel c, Boolean *useScreenBuffer);
pascal ComponentResult SGAlignChannelRect
(SGChannel c, Rect *r);

Configuration Functions for Sound Channel Components

pascal ComponentResult SGSetChannelVolume 
(SGChannel c, short volume);
pascal ComponentResult SGGetChannelVolume 
(SGChannel c, short *volume);
pascal ComponentResult SGSetSoundInputDriver 
(SGChannel c, const Str255 driverName);
pascal long SGGetSoundInputDriver 
(SGChannel c);
pascal ComponentResult SGSoundInputDriverChanged 
(SGChannel c);
pascal ComponentResult SGSetSoundRecordChunkSize 
(SGChannel c, long seconds);
pascal long SGGetSoundRecordChunkSize 
(SGChannel c);
pascal ComponentResult SGSetSoundInputRate 
(SGChannel c, Fixed rate);
pascal Fixed SGGetSoundInputRate 
(SGChannel c); 
pascal ComponentResult SGSetSoundInputParameters 
(SGChannel c, short sampleSize, 
short numChannels, OSType compressionType);
pascal ComponentResult SGGetSoundInputParameters 
(SGChannel c, short *sampleSize, 
short *numChannels, OSType *compressionType);

Utility Functions for Sequence Grabber Channel Components

pascal ComponentResult SGAddMovieData
(SeqGrabComponent s, SGChannel c, Ptr p, 
long len, long *offset, long chRefCon, TimeValue time, short writeType);
pascal ComponentResult SGWriteMovieData 
(SeqGrabComponent s, SGChannel c, 
Ptr p, long len, long *offset);
pascal ComponentResult SGAddFrameReference 
(SeqGrabComponent s, 
SeqGrabFrameInfo *frameInfo);
pascal ComponentResult SGGetNextFrameReference 
(SeqGrabComponent s, 
SeqGrabFrameInfo *frameInfo, 
TimeValue *frameDuration, 
long *frameNumber);
pascal ComponentResult SGSortDeviceList
(SeqGrabComponent s, SGDeviceList list);
pascal ComponentResult SGChangedSource 
(SeqGrabComponent s, SGChannel c);

Pascal Summary

Constants

CONST
   SeqGrabChannelType = 'sgch';{sequence grabber channel component type}


   {device list structure flags}
   sgDeviceListWithIcons               = 1;     {include icons}
   sgDeviceListDontCheckAvailability   = 2;     {don't check available }
                                                { device list}

   {flags for SGSetChannelPlayFlags and SGGetChannelPlayFlags functions}
   channelPlayNormal             = 0   {use default play methodology}
   channelPlayFast               = 1;  {sacrifice playback quality }
                                       { for specified rate}
   channelPlayHighQuality        = 2;  {sacrifice playback rate }
                                       { for image quality}
   channelPlayAllData            = 4;  {play all captured data }
                                       { including that stored in }
                                       { offscreen buffers}

   {flags for SGSetChannelUsage and SGGetChannelUsage functions}
   seqGrabRecord                 = 1;  {used during record operations}
   seqGrabPreview                = 2;  {used during preview operations}
   seqGrabPlayDuringRecord       = 4;  {used during record operations}

   {SGGetChannelInfo function flags}
   seqGrabHasBounds              = 1;  {visual representation of data}
   seqGrabHasVolume              = 2;  {audio representation of data}
   seqGrabHasDiscreteSamples     = 4;  {data organized in discrete frames}
   
   {basic sequence grabber channel component selectors}
   kSGSetGWorldSelect            = $4;    {SGSetGWorld}
   kSGStartPreviewSelect         = $10;   {SGStartPreview}
   kSGStartRecordSelect          = $11;   {SGStartRecord}
   kSGIdleSelect                 = $12;   {SGIdle}
   kSGStopSelect                 = $13;   {SGStop}
   kSGPauseSelect                = $14;   {SGPause}
   kSGPrepareSelect              = $15;   {SGPrepare}

   kSGReleaseSelect              = $16;   {SGRelease}
   kSGUpdateSelect               = $27;   {SGUpdate}

   {selectors for common channel configuration functions}
   kSGCSetChannelUsageSelect     = $80;   {SGCSetChannelUsage}
   kSGCGetChannelUsageSelect     = $81;   {SGCGetChannelUsage}
   kSGCSetChannelBoundsSelect    = $82;   {SGCSetChannelBounds}
   kSGCGetChannelBoundsSelect    = $83;   {SGCGetChannelBounds}
   kSGCSetChannelVolumeSelect    = $84;   {SGCSetChannelVolume}
   kSGCGetChannelVolumeSelect    = $85;   {SGCGetChannelVolume}
   kSGCGetChannelInfoSelect      = $86;   {SGCGetChannelInfo}
   kSGCSetChannelPlayFlagsSelect = $87;   {SGCSetChannelPlayFlags}      
   kSGCGetChannelPlayFlagsSelect = $88;   {SGCGetChannelPlayFlags}
   kSGCSetChannelMaxFramesSelect = $89;   {SGCSetChannelMaxFrames}
   kSGCGetChannelMaxFramesSelect = $8A;   {SGCGetChannelMaxFrames}
   kSGCSetChannelRefConSelect    = $8B;   {SGCSetChannelRefCon}
   kSGCSetChannelClipSelect      = $8C;   {SGSetChannelClip}
   kSGCGetChannelClipSelect      = $8D;   {SGGetChannelClip}
   kSGCGetChannelSampleDescriptionSelect 
                                 = $8E;   {SGCGetChannelSampleDescription}
   kSGCGetChannelDeviceListSelect = $8F;  {SGCGetChannelDeviceList}
   kSGCSetChannelDeviceSelect    = $90;   {SGCSetChannelDevice}
   kSGCSetChannelMatrixSelect    = $91;   {SGCSetChannelMatrix}
   kSGCGetChannelMatrixSelect    = $92;   {SGCGetChannelMatrix}
   kSGCGetChannelTimeScaleSelect = $93;   {SGCGetChannelTimeScale}
   
   {selectors for video channel configuration functions}
   kSGCGetSrcVideoBoundsSelect         = $100;  {SGCGetSrcVideoBounds}
   kSGCSetVideoRectSelect              = $101;  {SGCSetVideoRect}
   kSGCGetVideoRectSelect              = $102;  {SGCGetVideoRect}
   kSGCGetVideoCompressorTypeSelect    = $103;  {SGCGetVideoCompressorType}
   kSGCSetVideoCompressorTypeSelect    = $104;  {SGCSetVideoCompressorType}
   kSGCSetVideoCompressorSelect        = $105;  {SGCSetVideoCompressor}
   kSGCGetVideoCompressorSelect        = $106;  {SGCGetVideoCompressor}
   kSGCGetVideoDigitizerComponentSelect= $107;
                                             {SGCGetVideoDigitizerComponent}
   kSGCSetVideoDigitizerComponentSelect= $108;  
                                             {SGCSetVideoDigitizerComponent}
   kSGCVideoDigitizerChangedSelect     = $109;  {SGCVideoDigitizerChanged}
   kSGCSetVideoBottlenecksSelect       = $10A;  {SGCSetVideoBottlenecks}
   kSGCGetVideoBottlenecksSelect       = $10B;  {SGCGetVideoBottlenecks}
   kSGCGrabFrameSelect                 = $10C;  {SGCGrabFrame}
   kSGCGrabFrameCompleteSelect         = $10D;  {SGCGrabFrameComplete}
   kSGCDisplayFrameSelect              = $10E;  {SGCDisplayFrame}
   kSGCCompressFrameSelect             = $10F;  {SGCCompressFrame}
   kSGCCompressFrameCompleteSelect     = $110;  {SGCCompressFrameComplete}
   kSGCAddFrameSelect                  = $111;  {SGCAddFrame}
   kSGCTransferFrameForCompressSelect  = $112;  {SGCTransferFrameForCompress}
   kSGCSetCompressBufferSelect         = $113;  {SGCSetCompressBuffer}
   kSGCGetCompressBufferSelect         = $114;  {SGCGetCompressBuffer}
   kSGCGetBufferInfoSelect             = $115;  {SGCGetBufferInfo}
   kSGCSetUseScreenBufferSelect        = $116;  {SGCSetUseScreenBuffer}
   kSGCGetUseScreenBufferSelect        = $117;  {SGCGetUseScreenBuffer}
   kSGCGrabCompressCompleteSelect      = $118;  {SGCGrabCompressComplete}
   kSGCDisplayCompressSelect           = $119;  {SGCDisplayCompress}
   kSGCSetFrameRateSelect              = $11A;  {SGCSetFrameRate}
   kSGCGetFrameRateSelect              = $11B;  {SGCGetFrameRate}
    
   {selectors for sound channel configuration functions}
   kSGCSetSoundInputDriverSelect       = $100;  {SGCSetSoundInputDriver}
   kSGCGetSoundInputDriverSelect       = $101;  {SGCGetSoundInputDriver}
   kSGCSoundInputDriverChangedSelect   = $102;  {SGCSoundInputDriverChanged}
   kSGCSetSoundRecordChunkSizeSelect   = $103;  {SGCSetSoundRecordChunkSize}
   kSGCGetSoundRecordChunkSizeSelect   = $104;  {SGCGetSoundRecordChunkSize}
   kSGCSetSoundInputRateSelect         = $105;  {SGCSetSoundInputRate}
   kSGCGetSoundInputRateSelect         = $106;  {SGCGetSoundInputRate}
   kSGCSetSoundInputParametersSelect   = $107;  {SGCSetSoundInputParameters}
   kSGCGetSoundInputParametersSelect   = $108;  {SGCGetSoundInputParameters}

   {selectors for channel control functions}
   kSGCInitChannelSelect               = $180; {SGCInitChannel}
   kSGCWriteSamplesSelect              = $181; {SGCWriteSamples}
   kSGCGetDataRateSelect               = $182; {SGCDataRate}
   {values for the pause parameter of the SGPause function}
   seqGrabUnpause    = 0;     {restart current operation}
   seqGrabPause      = 1;     {pause the current operation}

Data Types

TYPE
   SeqGrabFrameInfo =
   RECORD
      frameOffset:      LongInt;    {offset to the sample}
      frameTime:        LongInt;    {time that frame was captured}
      frameChannel:     SGChannel;  {current connection to channel}
      frameRefCon:      LongInt;    {reference constant for channel}
   END;
SGDeviceListPtr = ^SGDeviceListRecord;
SGDeviceList = ^SGDeviceListPtr;
   SGDeviceListRecord =
   RECORD
      count:         Integer;                      {count of devices}
      selectedIndex: Integer;                      {current device}
      reserved:      LongInt;                      {set to 0}
      entry:         ARRAY[0..] OF SGDeviceName;   {device names}
   END;
   SGDeviceName =
   RECORD
      name:       Str63;      {device name}
      icon:       Handle;     {device icon}
      flags:      LongInt;    {flags}
      refCon:     LongInt;    {set to 0}
      reserved:   LongInt;    {set to 0}
}  END;

Routines

Configuring Sequence Grabber Channel Components

FUNCTION SGInitChannel (c: SGChannel; owner: SeqGrabComponent): 
ComponentResult;
FUNCTION SGSetGWorld (s: SeqGrabComponent; gp: CGrafPtr; 
gd: GDHandle): ComponentResult;

Controlling Sequence Grabber Channel Components

FUNCTION SGStartPreview (s: SeqGrabComponent): ComponentResult;
FUNCTION SGStartRecord (s: SeqGrabComponent): ComponentResult;
FUNCTION SGIdle (s: SeqGrabComponent): ComponentResult;
FUNCTION SGUpdate(s SeqGrabComponent; updateRgn RgnHandle): 
ComponentResult;
FUNCTION SGStop (s: SeqGrabComponent): ComponentResult;
FUNCTION SGWriteSamples (c: SGChannel; m: Movie; theFile: AliasHandle): 
ComponentResult;
FUNCTION SGPause (s: SeqGrabComponent; pause: Byte): 
ComponentResult;
FUNCTION SGPrepare (s: SeqGrabComponent; 
prepareForPreview: Boolean; 
prepareForRecord: Boolean): ComponentResult;
FUNCTION SGRelease (s: SeqGrabComponent): ComponentResult;

Configuration Routines for All Channel Components

FUNCTION SGSetChannelUsage (c: SGChannel; usage: LongInt): ComponentResult;
FUNCTION SGGetChannelUsage (c: SGChannel; 
VAR usage: LongInt): ComponentResult;
FUNCTION SGGetChannelInfo (c: SGChannel; 
VAR channelInfo: LongInt): ComponentResult;
FUNCTION SGSetChannelPlayFlags 
(c: SGChannel; playFlags: LongInt): ComponentResult;
FUNCTION SGGetChannelPlayFlags 
(c: SGChannel; VAR playFlags: LongInt): ComponentResult;
FUNCTION SGSetChannelMaxFrames 
(c: SGChannel; frameCount: LongInt): ComponentResult;
FUNCTION SGGetChannelMaxFrames
(c: SGChannel; VAR frameCount: LongInt): ComponentResult;
FUNCTION SGSetChannelRefCon 
(c: SGChannel; refCon: LongInt): ComponentResult;
FUNCTION SGGetDataRate (c: SGChannel; 
VAR bytesPerSecond: LongInt): ComponentResult;
FUNCTION SGGetChannelSampleDescription 
(c: SGChannel; sampleDesc: Handle): ComponentResult;
FUNCTION SGGetChannelTimeScale 
(c: SGChannel; VAR scale: TimeScale): ComponentResult;
FUNCTION SGSetChannelClip(c: SGChannel; theClip: RgnHandle): 
ComponentResult;
FUNCTION SGGetChannelClip(c: SGChannel; VAR theClip: RgnHandle): 
ComponentResult;
FUNCTION SGSetChannelMatrix 
(c: SGChannel; VAR m: MatrixRecord): ComponentResult;
FUNCTION SGGetChannelMatrix
(c: SGChannel; VAR m: MatrixRecord): ComponentResult;

Working With Channel Devices

FUNCTION SGGetChannelDeviceList 
(c: SGChannel; selectionFlags: LongInt; 
VAR list: SGDeviceList): ComponentResult;
FUNCTION SGSetChannelDevice 
(c: SGChannel; name: StringPtr): ComponentResult;

Configuration Routines for Video Channel Components

FUNCTION SGSetChannelBounds (c: SGChannel; bounds: Rect): ComponentResult;
FUNCTION SGGetChannelBounds (c: SGChannel; VAR bounds: Rect): 
ComponentResult;
FUNCTION SGGetSrcVideoBounds
(c: SGChannel; VAR r: Rect): ComponentResult;
FUNCTION SGSetVideoRect (c: SGChannel; r: Rect): ComponentResult;
FUNCTION SGGetVideoRect (c: SGChannel; VAR r: Rect): ComponentResult;
FUNCTION SGSetVideoCompressorType 
(c: SGChannel; 
compressorType: OSType): ComponentResult;
FUNCTION SGGetVideoCompressorType 
(c: SGChannel; 
VAR compressorType: OSType): ComponentResult;
FUNCTION SGSetVideoCompressor 
(c: SGChannel; depth: Integer; 
compressor: CompressorComponent; spatialQuality: CodecQ; 
temporalQuality: CodecQ; 
keyFrameRate: LongInt): ComponentResult;
FUNCTION SGGetVideoCompressor 
(c: SGChannel; VAR depth: Integer; 
VAR compressor: CompressorComponent; 
VAR spatialQuality: CodecQ; 
VAR temporalQuality: CodecQ; 
VAR keyFrameRate: LongInt): ComponentResult;
FUNCTION SGSetVideoDigitizerComponent 
(c: SGChannel; vdig: ComponentInstance): ComponentResult;
FUNCTION SGGetVideoDigitizerComponent 
(c: SGChannel): ComponentInstance;
FUNCTION SGVideoDigitizerChanged 
(c: SGChannel): ComponentResult;
FUNCTION SGSetCompressBuffer
(c: SGChannel; depth: Integer; 
compressSize: Rect): ComponentResult;
FUNCTION SGGetCompressBuffer
(c: SGChannel; VAR depth: Integer; 
VAR compressSize: Rect): ComponentResult;
FUNCTION SGSetFrameRate (c: SGChannel; frameRate: Fixed): 
ComponentResult;
FUNCTION SGGetFrameRate(c: SGChannel; VAR frameRate: Fixed): 
ComponentResult;
FUNCTION SGSetUseScreenBuffer 
(c: SGChannel; useScreenBuffer: Boolean): ComponentResult;
FUNCTION SGGetUseScreenBuffer 
(c: SGChannel; VAR useScreenBuffer: Boolean): ComponentResult;
FUNCTION SGAlignChannelRect
(c: SGChannel; VAR r: Rect): ComponentResult;

Configuration Routines for Sound Channel Components

FUNCTION SGSetChannelVolume
(c: SGChannel; volume: Integer): ComponentResult;
FUNCTION SGGetChannelVolume
(c: SGChannel; VAR volume: Integer): ComponentResult;
FUNCTION SGSetSoundInputDriver 
(c: SGChannel; driverName: Str255): ComponentResult;
FUNCTION SGGetSoundInputDriver 
(c: SGChannel): LongInt;
FUNCTION SGSoundInputDriverChanged 
(c: SGChannel): ComponentResult;
FUNCTION SGSetSoundRecordChunkSize 
(c: SGChannel; seconds: LongInt): ComponentResult;
FUNCTION SGGetSoundRecordChunkSize 
(c: SGChannel): LongInt;
FUNCTION SGSetSoundInputRate
(c: SGChannel; rate: Fixed): ComponentResult;
FUNCTION SGGetSoundInputRate
(c: SGChannel): Fixed; 
FUNCTION SGSetSoundInputParameters 
(c: SGChannel; sampleSize: Integer;
numChannels: Integer; 
compressionType: OSType): ComponentResult;
FUNCTION SGGetSoundInputParameters 
(c: SGChannel; VAR sampleSize: Integer; 
VAR numChannels: Integer; 
VAR compressionType: OSType): ComponentResult;

Utility Routines for Sequence Grabber Channel Components

FUNCTION SGAddMovieData(s: SeqGrabComponent; c: SGChannel; p: Ptr; 
len: LongInt; VAR offset: LongInt; 
chRefCon: LongInt; time: TimeValue; 
writeType: Integer): ComponentResult;
FUNCTION SGWriteMovieData (s: SeqGrabComponent; c: SGChannel; p: Ptr; 
len: LongInt; VAR offset: LongInt): 
ComponentResult;
FUNCTION SGAddFrameReference
(s: SeqGrabComponent; 
VAR frameInfo: SeqGrabFrameInfo): ComponentResult;
FUNCTION SGGetNextFrameReference 
(s: SeqGrabComponent; 
VAR frameInfo: SeqGrabFrameInfo; 
VAR frameDuration: TimeValue; 
VAR frameNumber: LongInt): ComponentResult;
FUNCTION SGSortDeviceList(s: SeqGrabComponent; list: SGDeviceList): 
ComponentResult;
FUNCTION SGChangedSource (s: SeqGrabComponent; c: SGChannel): 
ComponentResult;

Result Codes
noDeviceForChannel -9400Channel component cannot find its device
cantDoThatInCurrentMode-9402Request invalid in current mode
notEnoughMemoryToGrab-9403Insufficient memory for record operation
notEnoughDiskSpaceToGrab-9404Insufficient disk space for record operation
seqGrabInfoNotAvailable-9407Channel component cannot support request
deviceCantMeetRequest-9408Device cannot support grabber


Previous Book Contents Book Index Next

© Apple Computer, Inc.
7 JUL 1996




Navigation graphic, see text links

Main | Top of Section | What's New | Apple Computer, Inc. | Find It | Feedback | Help